home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Development Tools & Languages / Macintosh Common Lisp Related / User Contributions / zebu v3.3.3 (LALR parser) / ZEBU-sys.lisp < prev    next >
Encoding:
Text File  |  1994-09-12  |  14.3 KB  |  456 lines  |  [TEXT/ttxt]
  1. ; -*- mode:     CL -*- ----------------------------------------------------- ;
  2. ; File:         ZEBU-sys.lisp
  3. ; Description:  Definition of ZEBU, the cousin of Yacc (Runtime & Compiler)
  4. ; Author:       Joachim H. Laubsch
  5. ; Created:      11-Oct-90
  6. ; Modified:     Thu May 12 11:45:23 1994 (Joachim H. Laubsch)
  7. ; Language:     CL
  8. ; Package:      CL-USER
  9. ; Status:       Experimental (Do Not Distribute) 
  10. ; RCS $Header: $
  11. ;
  12. ; (c) Copyright 1990, Hewlett-Packard Company
  13. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  14. ; Revisions:
  15. ; RCS $Log: $
  16. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  17. (in-package "CL-USER")
  18.  
  19. (require "P-defsys")
  20. (use-package "DS" (find-package "CL-USER"))
  21.  
  22. ;; the binaries will be defined in a subdirectory camed "binary":
  23. (setq ds:*relative-binary-namestring* "binary")
  24. #+:KCL (setf (car ds:*suffixes*) "l")
  25.  
  26.  
  27.  
  28. ;; edit the following line to the pathname of this file if 
  29. ;; *LOAD-PATHNAME* is undefined in the CL used
  30. #+ALLEGRO 
  31. (setf *load-pathname* (merge-pathnames *load-pathname*
  32.                                        *default-pathname-defaults*))
  33.  
  34. #+LUCID
  35. (proclaim '(special *ZEBU-directory* *ZEBU-binary-directory*
  36.         *ZEBU-test-directory* *ZEBU-test-binary-directory*))
  37. #-LUCID
  38. (declaim (special *ZEBU-directory* *ZEBU-binary-directory*
  39.                   *ZEBU-test-directory* *ZEBU-test-binary-directory*))
  40.  
  41. (setf *ZEBU-directory*
  42.   (make-pathname :directory (pathname-directory *load-pathname*))
  43.   )
  44.  
  45. (setf *ZEBU-binary-directory*
  46.   (make-pathname :directory (append (pathname-directory *ZEBU-directory*)
  47.                     (list "binary"))))
  48.  
  49. (setf *ZEBU-test-directory*
  50.   (make-pathname :directory (append (pathname-directory *ZEBU-directory*)
  51.                     (list "test"))))
  52.  
  53. (setf *ZEBU-test-binary-directory*
  54.   (make-pathname :directory (append (pathname-directory *ZEBU-test-directory*)
  55.                     (list "binary"))))
  56.  
  57. ;; create binary directory if necessary
  58. (progn
  59.   #+LUCID
  60.   (or (probe-file *ZEBU-test-binary-directory*)
  61.       (shell (format nil "mkdir ~a" (namestring *ZEBU-test-binary-directory*))))
  62.   #+MCL
  63.   (create-file *ZEBU-test-binary-directory* :if-exists nil)
  64.   )
  65.  
  66. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  67. ;;                           Define the ZEBU package
  68. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  69. (load (merge-pathnames "zebu-package.lisp" *ZEBU-directory*))
  70.  
  71.  
  72. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  73. ;; compilation: Production mode
  74.  
  75. #+LUCID(proclaim '(optimize (speed 3) (safety 1) (compilation-speed 0)))
  76. #-LUCID(declaim (optimize (speed 3) (safety 1) (compilation-speed 0)))
  77.  
  78. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  79. ;;                                   Systems
  80. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  81.  
  82. (ds:defsystem "ZEBU-KERNEL"
  83.     (:default-pathname #.*ZEBU-directory*
  84.      :default-package  "ZEBU"
  85.      :documentation    "Functions needed in the ZEBU run-time and compile-time environment"
  86.      )
  87.   "zebu-package"
  88.   ("Version"              :type :text  :suffixes "")
  89.   ("zebu-aux"             :load-always "zebu-package"
  90.               :recompile-on "Version")
  91.   ("zebu-mg-hierarchy"    :load-always "zebu-aux")
  92.   )
  93.   
  94. (ds:load-module "zebu-package" :system "ZEBU-KERNEL")
  95.  
  96. (ds:defsystem "ZEBU"
  97.     (:default-pathname    #.*ZEBU-directory*
  98.      :default-package     "ZEBU"
  99.      :load-before-compile "ZEBU-KERNEL"
  100.      :needed-systems      "ZEBU-KERNEL"
  101.      :documentation       "Run time system for LALR(1) parser"
  102.      )
  103.   ("zebu-loader"          :load-always ("zebu-package" "zebu-aux"))
  104.   ("zebu-driver"          :load-always ("zebu-loader" "zebu-package"))
  105.   ("zebu-actions" :load-always ("zebu-loader"))
  106.   )
  107.  
  108. (ds:defsystem "ZEBU-COMPILER"
  109.     (:default-pathname    #.*ZEBU-directory*
  110.      :default-package     "ZEBU"    
  111.      :needed-systems      "ZEBU"
  112.      :load-before-compile "ZEBU-KERNEL"
  113.      :documentation       "Compile time system for LALR(1) parser: Converts a grammar to a parse table"
  114.      )
  115.   "zebu-regex"
  116.   "zebu-oset"
  117.   ("zebu-g-symbol"  :load-always "zebu-oset")
  118.   ("zebu-loadgram"  :load-always ("zebu-g-symbol" "zebu-oset"
  119.                   ("ZEBU" "zebu-loader")))
  120.   ("zebu-generator" :load-always ("zebu-kb-domain" "zebu-loadgram"))
  121.   ("zebu-lr0-sets"  :load-always ("zebu-g-symbol" "zebu-loadgram"))
  122.   ("zebu-empty-st"  :load-always ("zebu-loadgram"))
  123.   ("zebu-first"     :load-always ("zebu-loadgram" "zebu-oset")
  124.             :recompile-on "zebu-oset")
  125.   ("zebu-follow"    :load-always ("zebu-loadgram" "zebu-first"))
  126.   ("zebu-tables"    :load-always (("ZEBU" "zebu-loader")
  127.                   "zebu-g-symbol" "zebu-loadgram"
  128.                   "zebu-lr0-sets"))
  129.   ("zebu-printers"  :load-always ("zebu-loadgram" "zebu-lr0-sets" "zebu-tables"))
  130.   ("zebu-slr"       :load-always (("ZEBU" "zebu-loader")))
  131.   ("zebu-closure"   :load-always ("zebu-oset" "zebu-g-symbol" "zebu-first"))
  132.   ("zebu-lalr1"     :load-always (("ZEBU" "zebu-loader")
  133.                   "zebu-oset" "zebu-lr0-sets" "zebu-follow"))
  134.   ("zebu-dump"      :load-always ("zebu-loadgram" "zebu-slr" "zebu-lalr1"))
  135.   ("zebu-compile"   :load-before-compile "zebu-dump"
  136.             :load-always (("ZEBU-KERNEL" t)))
  137.   ("zebu-mg"        :load-always ("zebu-compile" "zebu-dump"
  138.                   "zebu-empty-st" "zebu-closure"
  139.                   "zebu-tables" "zebu-generator"
  140.                   ("ZEBU-KERNEL" t))
  141.             :compiler    ZB:zebu-compile-file
  142.             :loader      ZB:zebu-load-file
  143.             :suffixes    ("zb" . "tab"))
  144.   ("zebu-mg-domain" :recompile-on "zebu-mg")
  145.   "zebu-kb-domain" 
  146.   )
  147.  
  148. (ds:defsystem "ZEBU-RR"
  149.        (:default-pathname    #.*ZEBU-directory*
  150.     :needed-systems      "ZEBU"
  151.     :load-before-compile "ZEBU-KERNEL"
  152.     :documentation       "Base routines for rewriting abstract syntax trees"
  153.     )
  154.   "zebu-kb-domain"
  155.   ("zebu-tree-attributes"  :load-always  "zebu-kb-domain")
  156.   ("zebra-debug"           :load-always  ("zebu-kb-domain"
  157.                       "zebu-tree-attributes"))
  158.   )
  159.  
  160. (ds:defsystem zb::ZEBU-Test
  161.     (:default-pathname  #.*ZEBU-test-directory*
  162.      :needed-systems    ("ZEBU" "ZEBU-COMPILER")
  163.      :suffixes          ("zb" . "tab")
  164.      :compiler          zb:zebu-compile-file
  165.      :loader            zb:zebu-load-file
  166.      )
  167.   "ex1"
  168.   ("ex1-domain" :recompile-on "ex1" :type :lisp)
  169.   "arith-exp"                ; this uses the meta-grammar
  170.   ("arith-exp-domain" :recompile-on "arith-exp" :type :lisp)
  171.   "ex2"
  172.   ("ex2-domain" :recompile-on "ex2" :type :lisp)
  173.   "ex3"
  174.   "ex4.40"
  175.   "ex4.41"
  176.   "ex4.42"
  177.   "mini-la"                ; this uses the meta-grammar w Kleene
  178.   ("mini-la-domain" :recompile-on "mini-la" :compile-only t :type :lisp)
  179.   "useless"
  180.   "simple"
  181.   "lr4-21"
  182.   ("lr4-21-domain" :recompile-on "lr4-21" :compile-only t :type :lisp)
  183.   "ex6_2"
  184.   ("ex6_2-domain" :recompile-on "ex6_2" :compile-only t :type :lisp)
  185.   "pc"
  186.   ("pc-domain" :recompile-on "pc" :compile-only t :type :lisp)
  187.   "pc1"                    ; this uses the null-grammar
  188.   ("pc1-domain" :recompile-on "pc1" :compile-only t :type :lisp)
  189.   "pc2"                    ; this uses the meta-grammar
  190.   ("pc2-domain" :recompile-on "pc2" :compile-only t :type :lisp)
  191.   ;; don't compile the following:
  192.   ("exercise"   :suffixes  "lisp"  :type :lisp-example
  193.         :load-always (("ZEBU-RR" T)))
  194.   ("regex-test" :suffixes  "lisp"  :type :lisp-example)
  195.   )
  196. (provide "ZEBU-sys")
  197.  
  198. #||  Instructions
  199.  
  200. ;; (1) Load THIS file
  201. (load (format nil "~a/ZEBU-sys.lisp" (environment-variable "ZEBU")))
  202.  
  203. ;; (2) to compile the ZEBU runtime system
  204. (ds:compile-system "ZEBU"
  205.         ;; :recompile T
  206.         :include-components T)
  207.  
  208. ;; (3) to compile the ZEBU-Compiler system
  209. (ds:compile-system "ZEBU-COMPILER"
  210.         ;; :recompile T
  211.         )
  212. ;; (4) to load the ZEBU runtime system
  213. (ds:load-system "ZEBU")
  214.  
  215. ;; (5) to load the ZEBU-Compiler system
  216. (ds:load-system "ZEBU-COMPILER")
  217.  
  218. (ds:compile-system "ZEBU-RR")
  219.  
  220. ;; (6) to compile the test-gramamrs
  221. ;; You may want to omit this and rather import only a subset of the 
  222. ;; symbols or use package "ZEBU" in another package.
  223.  
  224. (use-package (find-package "ZEBU")
  225.          (find-package "CL-USER"))
  226.  
  227. (ds:compile-system "ZEBU-TEST"
  228.            :recompile t :include-components nil)
  229. (ds:show-system "ZEBU-TEST")
  230.  
  231. ;; (7) to test Zebu
  232. (ds:load-system "ZEBU-TEST")
  233. (ds:load-module "exercise")
  234.  
  235. ;; (8) the rewrite-rule extension
  236. (ds:compile-system "ZEBU-RR")
  237. (ds:load-system "ZEBU-RR")
  238.  
  239. (ds:show-system "ZEBU")
  240. (ds:show-system "ZEBU-KERNEL")
  241. (ds:show-system "ZEBU-COMPILER")
  242.  
  243. (ds:compile-module "zebu-mg")
  244.  
  245. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  246. ;;                                    Test
  247. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  248. ;; ex1 Grammar
  249. ; (:name "ex1" :package "CL-USER")
  250.  
  251. ; (defrule EE
  252. ;  := ( EE "+" TT )
  253. ;  :build (LIST 'expression EE '+ TT)
  254. ;  := TT
  255. ;  :build (LIST 'expression TT))
  256.  
  257. ; (defrule  TT 
  258. ;   := (TT "*" F)
  259. ;   :build (LIST 'term TT '* F)
  260.  
  261. ;   := F
  262. ;   :build (LIST 'term F) )
  263.  
  264. ; (defrule F 
  265. ;   := ( "(" EE ")" )
  266. ;   :build (LIST 'factor "(" EE ")")
  267. ;   
  268. ;   := IDENTIFIER
  269. ;   :build (list 'factor IDENTIFIER)
  270. ;   
  271. ;   := NUMBER
  272. ;   :build (list 'factor NUMBER))
  273.  
  274. (let ((*load-verbose* t))
  275.   (compile-slr-grammar
  276.    (merge-pathnames "ex1.zb" *ZEBU-test-directory*)
  277.    :output-file "/tmp/ex1.tab"))
  278. (setq zebu:*current-grammar*
  279.       (zebu-load-file "/tmp/ex1.tab"))
  280. (progn (format t "symbols: ") (terpri) (zebu::cruise-symbols-2))
  281. (zebu::print-productions)
  282. (zebu::print-collection nil)
  283. ;;(zebu::print-collection t)
  284. (print-actions (zebu::grammar-name zebu:*current-grammar*))
  285. (equal (read-parser "1 + a") (read-parser "1 + A"))
  286. (equal (list-parser '(1 "+" a)) (read-parser "1 + A"))
  287.  
  288. (list-parser '(1 "+" 1))
  289. (equal (read-parser "1 + 1") (list-parser '(1 "+" 1)))
  290. (equal (read-parser "1 + x * y") (list-parser '(1 "+" x "*" y)))
  291. (equal (read-parser "(1 + x) * y") (list-parser '("(" 1 "+" x ")" "*" y)))
  292. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  293. ;;                                     ex2
  294. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  295. ; (:name "ex2" :package "USER")
  296.  
  297. ; (defrule EE 
  298. ;     := (TT E-PRIME)
  299. ;     :build (cons TT E-PRIME) )
  300.  
  301. ; (defrule E-PRIME 
  302. ;     := ("+" TT E-PRIME)
  303. ;     :build list*
  304.  
  305. ;     := ())
  306.  
  307. ; (defrule TT 
  308. ;     := (FF T-PRIME)
  309. ;     :build (cons FF T-PRIME) )
  310.  
  311. ; (defrule T-PRIME 
  312. ;     := ("*" FF T-PRIME) 
  313. ;     :build list*
  314.  
  315. ;     := ())
  316.  
  317. ; (defrule FF
  318. ;     := ( "(" EE ")") 
  319. ;     := IDENTIFIER )
  320.  
  321. (compile-slr-grammar (merge-pathnames "ex2.zb" *ZEBU-test-directory*)
  322.              :output-file "/tmp/ex2.tab")
  323. (setq zebu:*current-grammar*
  324.       (setq $G1 (zebu-load-file "/tmp/ex2.tab")))
  325. (zebu::cruise-follow-sets)
  326. (zebu::print-productions)
  327. (zebu::cruise-parse-tables)
  328. (print-actions (zebu::grammar-name zebu:*current-grammar*))
  329.  
  330. (read-parser "ned + jed" :grammar $G1)
  331. (list-parser '(ned "+" jed ) :grammar $G1)
  332. (list-parser '(ned "+" jed ))
  333. (list-parser '(ned "+" "(" jed "*" fred ")"))
  334.  
  335. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  336. ;;                                     ex3
  337. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  338. ; (:name "ex3")
  339.  
  340. ; (defrule a 
  341. ;     := "b"
  342. ;     := ())
  343.  
  344. ; (defrule c 
  345. ;     := "b"
  346. ;     := ())
  347.  
  348.  
  349. ; (defrule d 
  350. ;     := (a c a))
  351.  
  352. ; (defrule e
  353. ;     := (a "f" a))
  354.  
  355.  
  356. (let (zebu:*allow-conflicts*)
  357.   (compile-lalr1-grammar
  358.    (merge-pathnames "ex3.zb" *ZEBU-test-directory*)
  359.    :output-file "/tmp/ex3.tab"))
  360. (setq $G3 (zebu-load-file "/tmp/ex3.tab"))
  361. (print-actions "ex3")
  362.  
  363. (list-parser '("b") :grammar $G3)
  364. (list-parser '() :grammar $G3)
  365.  
  366. (let ((zebu:*allow-conflicts* t))
  367.   (compile-slr-grammar
  368.    (merge-pathnames "ex3.zb" *ZEBU-test-directory*)
  369.    :output-file "/tmp/ex3.tab"))
  370.  
  371. (let ((zebu:*allow-conflicts* t))
  372.   (compile-lalr1-grammar
  373.    (merge-pathnames "ex3.zb" *ZEBU-test-directory*)
  374.    :output-file "/tmp/ex3.tab"))
  375.  
  376. (setq zebu:*current-grammar* (zebu-load-file "/tmp/ex3.tab"))
  377. (list-parser '( "b" ))
  378. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  379. ;;                                  dangelse
  380. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  381.  
  382. ; (let ((zebu:*allow-conflicts* t) (zebu::*WARN-CONFLICTS* t))
  383. ;   (compile-lalr1-grammar
  384. ;    (merge-pathnames "dangelse.zb" *ZEBU-test-directory*)
  385. ;    :output-file "/tmp/dangelse.tab"))
  386. ; equivalent to:
  387. (zebu-compile-file "$zebutest/dangelse.zb"
  388.            :output-file "/tmp/dangelse.tab")
  389. (zebu-load-file "/tmp/dangelse.tab")
  390.  
  391. (setq zebu:*current-grammar* (zb:find-grammar "dangelse"))
  392. (print-actions (zebu::grammar-name zebu:*current-grammar*))
  393.  
  394. (equal (list-parser '("if" f "then" g "else" h))
  395.        (read-parser "if f then g else h"))
  396.  
  397. (read-parser "if f then g ")
  398.  
  399. (read-parser "if f then if g then g1 else g2 else h")
  400.  
  401. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  402. ;;                                  lr4-21
  403. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  404. (zebu-compile-file "$zebutest/lr4-21.zb"
  405.            :output-file "$zebutest/lr4-21.tab")
  406. (zebu-load-file "$zebutest/lr4-21.tab")
  407.  
  408. (print-actions "lr4-21")
  409. (setq zebu:*current-grammar* (zb:find-grammar "lr4-21"))
  410. (read-parser "foo = 0")
  411. (read-parser "foo = x")
  412. (read-parser "*foo = x")
  413. (read-parser "*0 = x")
  414. (read-parser "**foo = ***x")
  415. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  416. ;;                           Propositional Calculus
  417. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  418. (let ((zebu:*allow-conflicts* nil))
  419.   (set-working-directory *ZEBU-test-directory*)
  420.   (compile-lalr1-grammar "pc1.zb")
  421.   (load (merge-pathnames "pc1-hierarchy" *ZEBU-test-directory*))
  422.   (load (merge-pathnames "pc1-printers" *ZEBU-test-directory*))
  423.   (setq zebu:*current-grammar* (zebu-load-file "pc1.tab"))
  424.   )
  425.  
  426. (read-parser "P")
  427. (read-parser "P and Q")
  428. (read-parser "P and Q and R")
  429. (read-parser "P and Q or R and S")
  430. (read-parser "(P and Q) or R and S")
  431. (read-parser "P and (Q or R) and S")
  432. (read-parser "P(a: 1 b:S)")
  433.  
  434. (print-actions "pc1")
  435. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  436. ;;                                  lr4-21.zb
  437. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  438. (zebu::compile-lalr1-grammar lr4-21.zb")
  439. (setq zebu:*current-grammar* (zebu-load-file "lr4-21.tab"))
  440.  
  441. (read-parser "x = 3")
  442. (read-parser "x = * * y")
  443.  
  444. (progn
  445.   (format t "~%lr0 item sets: ~%") 
  446.   (zebu::print-collection t)
  447.   (zebu::CRUISE-FOLLOW-SETS)
  448.   (format t "~%~%lalr(1) tables:~%")
  449.   (zebu::cruise-parse-tables)
  450.   )
  451. ||#
  452.  
  453. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  454. ;;                            End of ZEBU-sys.lisp
  455. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  456.